﻿#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
#include <functional>
#include <vector>
#include <algorithm>
#include <string>
#include <unordered_map>
#include <fstream>
#include <stack>
#include <memory>
#include <thread>
#include <chrono>

using namespace std;

auto err_msg = []()->void {
	std::cout << "test" << std::endl;
};
void Func()
{
	std::cout << "测试" << std::endl;
	return err_msg();
	std::cout << "1" << std::endl;
}

int main()
{
	Func();
	return 0;
}

//int main()
//{
//	int a;
//	cout << a << endl;
//
//	//int arr[5][5] = { {1,2,3,4,5}, {6,7,8,9,10} };
//	//cout << arr[0][1];
//
//	//int a = 1;
//	//auto e = [=]()mutable->int {cout << a << endl; a = 2; };
//	//cout << a << endl;
//	//return 0;
//}


//int main() 
//{
//	union 
//	{
//		int a;  //4 bytes
//		char b; //1 byte
//	}
//	data;
//	data.a = 1; 
//	if (1 == data.b)
//		printf("Little_Endian\n");
//	else
//		printf("big_endian");
//return 0;
//}

//int Func()
//{
//	cout << "static" << endl;
//	return 1;
//}
//
//int i = Func();
//
//int a = []() {
//	cout << "lambda" << endl;
//	return 0;
//	}();
//
//int main()
//{
//	cout << "main function" << endl;
//	
//	return 0;
//}

//class A {
//public:
//	~A() {
//		throw std::runtime_error("析构异常");
//	}
//};
//
//void f() {
//	A a;
//	throw std::runtime_error("函数异常");  // 如果这个异常抛出，a 被销毁时再抛异常，就会 terminate
//}
//
//class B
//{
//public:
//	B(int a)
//	{
//		_a = a;
//	}
//private:
//
//	int _a;
//};
//
//class C : public B
//{
//public:
//	C(int a)
//		:_a(1), _b(a),B(a)
//	{
//		
//	}
//
//private:
//	const int _a;
//	int& _b;
//};


//class Base
//{
//private:
//	int _a;
//};
//
//class Drive : public Base
//{
//private:
//	int _b;
//};
//class B;
//
//class A
//{
//public:
//	friend void Func(const A& pa, const B& pb);
//protected:
//	int _a = 1;
//};
//
//class B : public A
//{
//	//public:
//protected:
//	int _b = 2;
//};
//
//void Func(const A& pa, const B& pb)
//{
//	cout << pa._a << endl;
//	// cout << pb._b << endl;
//}
//
//int main()
//{
//	A a;
//	B b;
//	Func(a, b);
//	return 0;
//}


//class A
//{	
//public:
//	A()
//	{
//		_str = new string("aaaa");
//	}
//private:
//	string* _str;
//};
//class A 
//{
//public:
//	A() 
//	{
//		_str = new char[4];  // 手动分配内存
//		strcpy(_str, "aaa");
//	}
//
//	~A() 
//	{
//		delete[] _str;  // 需要手动释放
//	}
//
//private:
//	char* _str;  // 原始指针
//};
//
//void Test_string()
//{
//	string* s1 = new string("123456");
//	string* s2(s1);
//
//	s1[2] = 'x';
//
//	cout << s1 << endl;
//	cout << s2 << endl;
//}
//
//int main()
//{
//	//A a;
//	//A b = a;
//
//	Test_string();
//	return 0;
//}

//class A
//{
//public:
//
//	virtual void func1() { cout << "A::func1" << endl; }
//	int _a;
//};
//class B : virtual public A
//{
//public:
//	virtual void func2() { cout << "B::func2" << endl; }
//	int _b;
//};
//class C : virtual public A
//{
//public:
//	virtual void func3() { cout << "C::func3" << endl; }
//	int _c;
//};
//class D : public B, public C
//{
//public:
//	virtual void func2() { cout << "D::func2" << endl; }
//	virtual void func4() { cout << "D::func4" << endl; }
//	int _d;
//};
//
//int main()
//{
//	D d;
//	cout << sizeof(d) << endl;
//	d.B::_a = 1;
//	d.C::_a = 2;
//	d._b = 3;
//	d._c = 4;
//	d._d = 5;
//	return 0;
//}

//class Base
//{
//public:
//	virtual void Func1()
//	{
//		cout << "Base::Func1()" << endl;
//	}
//	virtual void Func2()
//	{
//		cout << "Base::Func2()" << endl;
//	}
//
//private:
//	int _b = 1;
//};
//class Drive :public Base
//{
//public:
//	virtual void Func1()
//	{
//		cout << "Drive::Func1()" << endl;
//	}
//	virtual void Func3()
//	{
//		cout << "Drive::Func3()" << endl;
//	}
//	virtual void Func4()
//	{
//		cout << "Drive::Func4()" << endl;
//	}
//private:
//	int _a = 2;
//};
//
//typedef void(*VFPTR)();
//
//void PrintVFT(VFPTR* vft)
//{
//	for (size_t i = 0; i < 4; i++)
//	{
//		printf("%p", vft[i]);
//		VFPTR pf = vft[i];
//		(*pf)();
//	}
//}
//
//void PrintVFT(void** vft)
//{
//	for (size_t i = 0; i < 4; ++i)
//	{
//		printf("vft[%zu] = %p -> ", i, vft[i]);
//		if (vft[i]) {
//			using VFunc = void(*)();  // 虚函数统一转成无参无返回函数指针
//			VFunc f = reinterpret_cast<VFunc>(vft[i]);
//			f(); // 调用
//		}
//	}
//}

//class Base {
//public:
//	Base() {
//		cout << "Base constructor call:" << endl;
//		Func();  // 多态失效
//	}
//	virtual void Func() {
//		cout << "Base::Func" << endl;
//	}
//};
//
//class Derived : public Base {
//public:
//	Derived() {
//		cout << "Derived constructor call:" << endl;
//		Func();  // 多态生效
//	}
//	void Func() override {
//		cout << "Derived::Func" << endl;
//	}
//};
//
//int main() {
//	Derived d;
//	return 0;
//}


//int main()
//{
//	Base b1;
//	Drive d1;
//
//	cout << &b1 << endl;
//	cout << *(void**)&b1 << endl;
//
//	/*VFPTR* ptr = (VFPTR*)(*((int*)&d1));
//	PrintVFT(ptr);*/
//	
//	PrintVFT(*((void***)&d1));
//	return 0;
//}



//class Base 
//{
//public:
//	virtual void Func1()
//	{
//		cout << "Base1" << endl;
//	}
//
//	virtual void Func2()
//	{
//		cout << "Base2" << endl;
//	}
//	
//	~Base()
//	{
//		cout << "~Base" << endl;
//	}
//};
//
//class Drive : public Base
//{
//public:
//	void Func1() override
//	{
//		cout << "Drive1" << endl;
//	}
//
//	void Func2() override
//	{
//		cout << "Drive2" << endl;
//	}
//
//	~Drive()
//	{
//		cout << "~Drive" << endl;
//	}
//};
//
//
//int main()
//{
//	//Base* pb = new Drive;
//	//pb->Func1();
//	//delete pb;
//
//	Base* pb1 = new Base;
//	Base* pb2 = new Drive;
//	delete pb1;
//	delete pb2;
//
//	return 0;
//}

//volatile int a = 0;
//volatile int b = 0;

//int a = 0;
//int b = 0;
//
//void write() {
//	a = 1;  // 写a
//	b = 1;  // 写b
//}
//
//void read() {
//	while (b == 0) {}  // 等待b被置为1
//	if (a == 0) {
//		std::cout << "Reordering detected!" << std::endl;
//	}
//}
//
//int main() {
//	std::thread t1(write);
//	std::thread t2(read);
//
//	t1.join();
//	t2.join();
//
//	return 0;
//}
//

// bool flag = false;
//
//void thread_func() {
//	std::this_thread::sleep_for(std::chrono::seconds(1));
//	flag = true;  // 另一个线程修改flag
//	std::cout << "Flag set to true in thread_func\n";
//}
//
//int main() {
//	std::thread t(thread_func);
//
//	// 主线程等待flag变成true
//	while (!flag) {
//		// 如果没有volatile，这个循环可能被优化成死循环
//	}
//	std::cout << "Detected flag change!\n";
//
//	t.join();
//	return 0;
//}


//void* operator new(size_t size) 
//{
//	std::cout << "Allocating " << size << " bytes\n";
//	return malloc(size);
//}
//
//class MyClass 
//{
//public:
//	MyClass(int x) { std::cout << "Constructor called: " << x << "\n"; }
//};
//
//int main() 
//{
//	MyClass* p = new MyClass(42);
//	return 0;
//}


//int Add(int x, int y)
//{
//	return x + y;
//}
//
//typedef int(*pa)(int, int);
//
//
//void Func(int x, pa f)
//{
//	f(x, 2);
//}
//
//int main()
//{
//	pa f = Add;
//	cout << f(1, 2) << endl;
//	return 0;
//}

//class Base {
//public:
//	virtual ~Base() {}
//};
//
//class Derived : public Base {
//public:
//	void hello() { cout << "Hello from Derived\n"; }
//};
//
//int main() {
//	Derived d;
//	Base* pb1 = &d; // ✅ 上行转换
//	pb1 = new Derived;
//
//	// ✅ 下行转换（正确，因为真实类型是 Derived）
//	Derived* pd1 = dynamic_cast<Derived*>(pb1);
//	if (pd1) pd1->hello();
//
//	// ❌ 错误下行转换
//	Base* pb2 = new Base;
//	Derived* pd2 = dynamic_cast<Derived*>(pb2);  // 返回 nullptr
//	Derived* pd3 = static_cast<Derived*>(pb2);
//	pd3->hello();
//	if (!pd2) cout << "pb2 不是 Derived 类型，转换失败\n";
//
//	delete pb1;
//	delete pb2;
//}

//class A
//{
//public:
//	A()
//	{
//	}
//	A(A&& pa) noexcept
//		:_size(move(pa._size)),_a(move(pa._a))
//	{
//	}
//
//	size_t _size = 10;
//	int* _a = new int;
//};

//#include <iostream>
//#include <stdexcept>
//
//void danger() noexcept {
//	throw std::runtime_error("Oops!");  // 明明说了 noexcept，却 throw 了
//}
//
//int main() {
//	danger();
//	std::cout << "This line will never run\n";
//}


//struct A {
//	A() {}
//	A(const A&) {
//		std::cout << "copy\n";
//	}
//	A(A&&) noexcept {
//		std::cout << "move\n";
//	}
//};
//
//int main() {
//	std::vector<A> vec;
//	vec.reserve(1);
//	vec.emplace_back();  // 第一次放进去
//	vec.emplace_back();  // 第二次扩容，搬元素：会打印 "move"
//}
//int main()
//{
//	//A aa;
//	//cout << &(*aa._a) << endl;
//	//A ab(move(aa));
//	//cout << &(*ab._a) << endl;
//	std::vector<A> vec;
//	vec.reserve(1);
//	vec.emplace_back();  // 第一次放进去
//	vec.emplace_back();  // 第二次扩容，搬元素：会打印 "move"
//	return 0;
//}


//#include <iostream>
//#include <string>
//using namespace std;
//
//class Person
//{
//private:
//    string name;
//    int age;
//
//public:
//    // 1. 默认构造函数
//    Person()
//        : name("Unknown"), age(0)
//    {
//        cout << "Default constructor called!" << endl;
//    }
//
//    // 2. 带参构造函数 (可以带默认参数)
//    Person(string n, int a)
//        : name(n), age(a)
//    {
//        cout << "Parameterized constructor called!" << endl;
//    }
//
//    // 3. 拷贝构造函数
//    Person(const Person& other)
//        : name(other.name), age(other.age)
//    {
//        cout << "Copy constructor called!" << endl;
//    }
//
//    // 4. 移动构造函数
//    Person(Person&& other) noexcept
//        : name(move(other.name)), age(other.age)
//    {
//        cout << "Move constructor called!" << endl;
//        other.age = 0;  // 清空其他对象的内容
//    }
//
//    // 5. 委托构造函数 (C++11+)
//    Person(string n) : Person(n, 30)  // 委托给带参构造函数
//    {
//        cout << "Delegating constructor called!" << endl;
//    }
//
//    // 输出成员信息
//    void printInfo() const
//    {
//        cout << "Name: " << name << ", Age: " << age << endl;
//    }
//};
//
//int main()
//{
//    cout << "Creating p1 using default constructor:" << endl;
//    Person p1;  // 默认构造函数
//
//    cout << "\nCreating p2 using parameterized constructor:" << endl;
//    Person p2("Alice", 25);  // 带参构造函数
//
//    cout << "\nCreating p3 using copy constructor:" << endl;
//    Person p3 = p2;  // 拷贝构造函数
//
//    cout << "\nCreating p4 using move constructor:" << endl;
//    Person p4 = std::move(p2);  // 移动构造函数
//
//    cout << "\nCreating p5 using delegating constructor:" << endl;
//    Person p5("Bob");  // 委托构造函数
//
//    // 输出每个对象的成员信息
//    p1.printInfo();
//    p2.printInfo();
//    p3.printInfo();
//    p4.printInfo();
//    p5.printInfo();
//
//    return 0;
//}


//void Func(int, int);

//void swap(vector<T>& v)
//{
//	std::swap(this->_start, v._start);
//	std::swap(_finish, v._finish);
//	std::swap(_end_of_storage, v._end_of_storage);
//}
//

//
//class A
//{
//public:
//	A(int a = 1)
//		:_a(a)
//	{
//	}
//
//	void Func() 
//	{
//		this->_a = 2;
//	}
//	int Get()
//	{
//		return _a;
//	}
//	void Set(int a = 1)
//	{
//		_a = a;
//	}
//private:
//	int _a;
//};
//
//void Func(int a)
//{
//	cout << endl;
//}
//
//int main()
//{
//	A a();
//	int b = 1;
//	Func(b);
//	return 0;
//}
//
//int main()
//{
//	A* p1 = (A*)malloc(sizeof(A));
//	A* p2 = new A(); // new = malloc + 初始化 + 抛异常 malloc + 初始化 = operator new
//	cout << p1->_a << endl;
//	cout << p2->_a << endl;
//
//	return 0;
//}
	//int arr[3] = { 1, 2, 3 };
	//for (int i = 0; i < 3; ++i)
	//{
	//	cout << i[arr] << endl;
	//	cout << arr[i] << endl;
	//	cout << *(arr + i) << endl;
	//	cout << *(i + arr) << endl;
	//}
	//int* pa = new int();
	////int a = 0x11223344;
	////char* p = (char*) &a;
	////*p = 0x55;
	////printf("%x", a);

//extern int a;
//
//class Test
//{
//public:
//	Test(int a = 1)
//		:_a(a)
//	{
//	}
//
//	void func()
//	{
//		cout << "Hello world" << endl;
//	}
//
//	static void func2()
//	{
//		cout << "Hello world 2" << endl;
//		cout << _b << endl;
//	}
//
//private:
//	int _a;
//
//public:
//	static int _b;
//};
//
//int Test::_b = 2;
//
//class Test_1
//{
//public:
//	Test_1(int a)
//		:_a(a)
//	{
//	}
//
//private:
//	int _a;
//
//};

//class a
//{
//public:
//	virtual void func()
//	{
//		cout << "1" << endl;
//	}
//};
//
//class b : public a
//{
//public:
//	static virtual void func() override
//	{
//		cout << "2" << endl;
//	}
//};

//class A
//{
//public:
//	void print() const
//	{
//		cout << _a << " " << b << endl;
//		//this->_a = 2;  // const 修饰的是*this
//	}
//	A(int a)
//		:_a(a), b(2)
//	{
//		//b = 2;
//	}
//private:
//	int _a;
//	const int b;
//};
//
//int main()
//{
//	//cout << a << endl;
//	//Test t1;
//	//cout << Test::_b;
//	//Test::func2();
//
//	A a(1);
//	a.print();
//	a.print();
//
//	return 0;
//}

//struct B;
//
//struct A
//{
//	shared_ptr<B> _b;
//	A()
//	{
//		cout << "A c" << endl;
//	}
//	~A()
//	{
//		cout << "A d" << endl;
//	}
//};
//
//struct B
//{
//	weak_ptr<A> _a;
//	B()
//	{
//		cout << "B c" << endl;
//	}
//	~B()
//	{
//		cout << "B d" << endl;
//	}
//};
//
//int main()
//{
//	auto pa = make_shared<A>();
//	auto pb = make_shared<B>();
//	pa->_b = pb;
//	pb->_a = pa;
//
//	return 0;
//}


//struct A {
//	A() { std::cout << "A 构造 at " << this << std::endl; }
//	~A() { std::cout << "A 析构 at " << this << std::endl; }
//
//	void* operator new(size_t size) {
//		void* p = ::operator new(size);
//		std::cout << "[A::operator new] 分配地址: " << p << std::endl;
//		return p;
//	}
//};
//
//int main() {
//	auto p1 = std::make_shared<A>();       // 一次内存分配（隐藏控制块）
//	auto p2 = std::shared_ptr<A>(new A()); // 两次内存分配
//
//	return 0;
//}

//struct A 
//{
//    A() { std::cout << "构造：" << this << std::endl; }
//    ~A() { std::cout << "析构：" << this << std::endl; }
//};
//
//// 打印对象地址和控制块地址
//template<typename T>
//void print_info(const std::shared_ptr<T>& sp, const std::string& label) 
//{
//    std::weak_ptr<T> wp = sp;
//
//    // 获取原始对象地址
//    void* obj_addr = static_cast<void*>(sp.get());
//
//    // 观察 weak_ptr 地址（它间接指向控制块）
//    void* ctrl_block_addr = reinterpret_cast<void*>(&wp);
//
//    std::cout << "==== " << label << " ====" << std::endl;
//    std::cout << "对象地址：      " << obj_addr << std::endl;
//    std::cout << "控制块（估计）：" << ctrl_block_addr << std::endl;
//    std::cout << std::endl;
//}
//
//int main() {
//    // 使用 make_shared（对象和控制块通常是连续的）
//    auto p1 = std::make_shared<A>();
//    print_info(p1, "make_shared");
//
//    // 使用 new A（对象和控制块分开分配）
//    auto p2 = std::shared_ptr<A>(new A());
//    print_info(p2, "shared_ptr(new)");
//
//    return 0;
//}


//class A
//{
//public:
//	using ptr = std::shared_ptr<A>;
//
//	A()
//	{
//		cout << "构造ing..." << endl;
//	}
//
//	~A()
//	{
//		cout << "析构int..." << endl;
//	}
//};

//struct A {
//	int x = 100;
//	A() { std::cout << "构造：" << this << std::endl; }
//	~A() { std::cout << "析构：" << this << std::endl; }
//};
//
//int main() {
//	auto sp1 = std::make_shared<A>();
//	std::cout << "make_shared A @" << sp1.get() << std::endl;
//
//	auto sp2 = std::shared_ptr<A>(new A());
//	std::cout << "shared_ptr(new A) @" << sp2.get() << std::endl;
//}

//A::ptr Func()
//{
//	return A::ptr();
//}
//
//A::ptr Funb()
//{
//	return make_shared<A>();
//}
//
//int main()
//{
//	auto e = Func();
//	e.get() == nullptr ? cout << 1 : cout << 2;
//	auto ec = Funb();
//	ec.get() == nullptr ? cout << 1 : cout << 2;
//	return 0;
//}
//	auto_ptr<string> p1(new string("aaaa"));
//	auto_ptr<string> p2 = p1; //所有权转移，导致悬空指针
//	//cout << *p1 << " " << *p2;
//
//	unique_ptr<string> p3(new string("aaaa"));
//	//unique_ptr<string> p4 = p3; // 实现原理-> delete copy
	/*
	shared_ptr<A> p1(new A);
	cout << p1.use_count() << endl;
	shared_ptr<A> p2 = p1;
	cout << p1.use_count() << endl;
	cout << p2.use_count() << endl;

	p2.reset();
	cout << p1.use_count() << endl;*/

	//A* pa = new A;
	//shared_ptr<A> p1(pa);
	//shared_ptr<A> p2(pa); // 重复释放问题 独立管理相同内存 // 常见函数reset usecount get
	//
//int main()
//{
//    string str = u;
//    char ch = '1';
//    //cin >> str;
//    stack<char> res;
//    for (int i = 0; i < str.size(); ++i)
//    {
//        if (!res.empty())
//            ch = res.top();
//        if (ch == str[i]) res.pop();
//        else    res.push(str[i]);
//    }
//    if (res.empty())
//    {
//        cout << 0;
//        return 0;
//    }
//    vector<char> vec;
//    while (!res.empty())
//    {
//        char ch = res.top();
//        res.pop();
//        vec.push_back(ch);
//    }
//    for (int i = vec.size() - 1; i >= 0; --i)
//    {
//        cout << vec[i];
//    }
//    return 0;
//}

//size_t split(const std::string& str, const std::string& sep, std::vector<std::string>& result)
//{
//    size_t pos = 0, idx = 0;
//    while (idx < str.size())
//    {
//        pos = str.find(sep, idx);
//        // 末端
//        if (pos == std::string::npos)
//        {
//            result.push_back(str.substr(idx));
//            return result.size();
//        }
//        // 重复分隔符
//        if (pos == idx)
//        {
//            idx = pos + sep.size();
//            continue;
//        }
//        result.push_back(str.substr(idx, pos - idx));
//        idx = pos + sep.size();
//    }
//    return result.size();
//}
//
//
//int main()
//{
//    vector<string> sub_words;
//
//    split("new.music.pop.*", ".", sub_words);
//    for (string s : sub_words)
//    {
//        cout << s << endl;
//    }
//
//    //sub_words.push_back("news");
//    //sub_words.push_back("music");
//    //sub_words.push_back("pop");
//    //for (int i = 1; i < sub_words.size(); i++) {
//    //    if (sub_words[i] == "#" && sub_words[i - 1] == "*") {
//    //        return false;
//    //    }
//    //    if (sub_words[i] == "#" && sub_words[i - 1] == "#") {
//    //        return false;
//    //    }
//    //    if (sub_words[i] == "*" && sub_words[i - 1] == "#") {
//    //        return false;
//    //    }
//    //}
//    
//	return 0;
//}

//int main()
//{
//	std::string str = "./aaa.txt";
//	fstream ss(str, std::ios::binary | std::ios::out);
//	return 0;
//}

//int main()
//{	
//	unordered_map<std::string, std::string> um;
//	string &str = um["hello"];
//	str = "world";
//	auto it = um.begin();
//	cout << it->first << " " << it->second;
//	return 0;
//}

//void f1(string p1)
//{
//	cout << "1";
//}
//
//void f2(const string p2)
//{
//	cout << "2";
//}
//
//int main()
//{
//	char a[111] = "aafadsf";
//	char* p = a;
//	f1(p);
//	f2(p);
//	return 0;
//}


//void Func1(vector<int>& vec)
//{
//	vec.push_back(1);
//}
//
//void Func2(vector<int>& vec)
//{
//	vec.push_back(2);
//}
//
//int main()
//{
//	vector<int> vec;
//	//Func1(vec);
//	Func2(vec);
//
//	for (auto e : vec)
//	{
//		cout << e << " ";
//	}
//	return 0;
//}

//std::string GetCurTime()
//{
//    const time_t cur_time = time(nullptr); // 获取当前时间戳
//    struct tm* t = localtime(&cur_time); // 将时间戳转换为tm结构体
//    char time_buf[128];
//    snprintf(time_buf, sizeof(time_buf), "%d-%02d-%02d %02d:%02d:%02d", 
//        t->tm_year + 1900,
//        t->tm_mon + 1,
//        t->tm_mday,
//        t->tm_hour,
//        t->tm_min,
//        t->tm_sec
//    );
//    return time_buf;
//}
//
//int main()
//{
//	cout << to_string(111) << endl;
//    cout << GetCurTime() << endl;
//	return 0;
//}

//class A
//{
//public:
//	A(int a = 1)
//		:_a(a)
//	{}
//private:
//	int _a;
//};
//
//int main()
//{
//	//cout << __TIME__ << endl;
//	string s1 = "aaa";
//	cout << &s1 << endl;
//	string s2 = move(s1);
//	cout << &s1 << endl;
//	cout << &s2 << endl;
//
//
//	return 0;
//}


//void modify(std::string& s) 
//{
//    s += " world";
//}
//
//template <typename F, typename... Args>
//auto wrapper(F&& f, Args&&... args) 
//{
//    return std::bind(std::forward<F>(f), std::forward<Args>(args)...);
//}
//
//int main() {
//    std::string str = "hello";
//    auto task = wrapper(modify, std::ref(str));  // ❌ 注意：这里虽然是引用，但没有显式加 std::ref
//    task();  // 执行任务
//    std::cout << str << std::endl;  // 输出: hello（没有被修改！）
//    return 0;
//}


//class A
//{
//private:
//	int _a;
//};
//
//
//int main()
//{
//	void* buffer = malloc(sizeof(1024));
//	
//	A* pa = new ((char*)buffer + sizeof(A)) A;
//	//A* pa = new ((int*)buffer + sizeof(A)) A;
//
//	cout << pa << endl;
//	cout << buffer << endl;
//
//	return 0;
//}

//#include <climits>
//using namespace std;
//
//class CoinChangeSolver {
//public:
//    // 主函数：返回最少硬币数，不能组成返回 -1
//    int coinChange(const vector<int>& coins, int amount) {
//        vector<int> dp(amount + 1, INT_MAX);
//        dp[0] = 0;
//
//        for (int coin : coins) {
//            for (int i = coin; i <= amount; ++i) {
//                if (dp[i - coin] != INT_MAX) {
//                    dp[i] = min(dp[i], dp[i - coin] + 1);
//                }
//            }
//        }
//
//        return dp[amount] == INT_MAX ? -1 : dp[amount];
//    }
//};
//
//// 测试函数
//void runTests() {
//    CoinChangeSolver solver;
//
//    vector<int> coins1 = { 1, 2, 5 };
//    int amount1 = 11;
//    cout << "Test 1: " << solver.coinChange(coins1, amount1) << " (Expected: 3)" << endl;
//
//    vector<int> coins2 = { 2 };
//    int amount2 = 3;
//    cout << "Test 2: " << solver.coinChange(coins2, amount2) << " (Expected: -1)" << endl;
//
//    vector<int> coins3 = { 1 };
//    int amount3 = 0;
//    cout << "Test 3: " << solver.coinChange(coins3, amount3) << " (Expected: 0)" << endl;
//
//    vector<int> coins4 = { 186, 419, 83, 408 };
//    int amount4 = 6249;
//    cout << "Test 4: " << solver.coinChange(coins4, amount4) << " (Expected: 20)" << endl;
//}

//class LoadingSolver {
//public:
//    int maxLoad(const vector<int>& weights, int capacity) {
//        vector<int> dp(capacity + 1, 0);
//        for (int w : weights) {
//            for (int j = capacity; j >= w; --j) {
//                dp[j] = max(dp[j], dp[j - w] + w);
//            }
//        }
//        return dp[capacity];
//    }
//};
//
//void testLoadingSolver() {
//    LoadingSolver solver;
//
//    vector<int> w1 = { 1, 3, 4, 5 };
//    int cap1 = 7;
//    cout << "Test 1: " << solver.maxLoad(w1, cap1) << " (Expected: 7)" << endl;
//
//    vector<int> w2 = { 2, 2, 4, 6, 3 };
//    int cap2 = 9;
//    cout << "Test 2: " << solver.maxLoad(w2, cap2) << " (Expected: 9)" << endl;
//
//    vector<int> w3 = { 5, 5, 5 };
//    int cap3 = 10;
//    cout << "Test 3: " << solver.maxLoad(w3, cap3) << " (Expected: 10)" << endl;
//}

//class SubsetSolver {
//public:
//    vector<vector<int>> subsets(vector<int>& nums) {
//        vector<vector<int>> result;
//        vector<int> current;
//        backtrack(nums, 0, current, result);
//        return result;
//    }
//
//private:
//    void backtrack(const vector<int>& nums, int index, vector<int>& current, vector<vector<int>>& result) {
//        result.push_back(current);
//        for (int i = index; i < nums.size(); ++i) {
//            current.push_back(nums[i]);
//            backtrack(nums, i + 1, current, result);
//            current.pop_back();
//        }
//    }
//};
//
//void testSubsetSolver() {
//    SubsetSolver solver;
//    vector<int> nums = { 1, 2, 3 };
//    auto res = solver.subsets(nums);
//    cout << "Test 1: Subsets of [1, 2, 3]:" << endl;
//    for (const auto& subset : res) {
//        cout << "{ ";
//        for (int x : subset) cout << x << " ";
//        cout << "}" << endl;
//    }
//}
//
//
//int main()
//{
//    testSubsetSolver();
//
//    return 0;
//}


//int maxIntercepts(const vector<int>& missiles) {
//    int n = missiles.size();
//    if (n == 0) return 0;
//
//    vector<int> dp(n, 1); // 初始化每个位置长度为1
//    int maxLen = 1;
//
//    for (int i = 1; i < n; ++i) {
//        for (int j = 0; j < i; ++j) {
//            if (missiles[j] >= missiles[i]) {
//                dp[i] = max(dp[i], dp[j] + 1);
//            }
//        }
//        maxLen = max(maxLen, dp[i]);
//    }
//
//    return maxLen;
//}
//
//int main() {
//    vector<int> missiles;
//    int height;
//    while (cin >> height) {
//        if (height == 0) break;
//        missiles.push_back(height);
//    }
//    cout << maxIntercepts(missiles) << endl;
//    return 0;
//}


//class A
//{
//
//	int a;
//};

//int main()
//{
//
//
//	/*A* ta = new A[3];
//	
//	delete[] ta;
//	*/return 0;
//}


//#include <iostream>
//#include <vector>
//#include <algorithm>
//using namespace std;
//
//class Solution {
//public:
//    // 使用一维数组进行空间优化
//    int maximumTotal(vector<vector<int>>& triangle) {
//        if (triangle.empty()) return 0;
//        int n = triangle.size();
//        vector<int> dp(triangle.back()); // 初始化为最后一层
//
//        // 从倒数第二层开始向上推
//        for (int i = n - 2; i >= 0; --i) {
//            for (int j = 0; j <= i; ++j) {
//                dp[j] = triangle[i][j] + max(dp[j], dp[j + 1]);
//            }
//        }
//        return dp[0];
//    }
//};
//
//int main() 
//{
//    int n;
//    cin >> n; // 读入三角形层数
//    vector<vector<int>> triangle(n);
//
//    for (int i = 0; i < n; ++i) {
//        triangle[i].resize(i + 1);
//        for (int j = 0; j <= i; ++j) {
//            cin >> triangle[i][j];
//        }
//    }
//
//    Solution sol;
//    int result = sol.maximumTotal(triangle);
//    cout << result << endl;
//
//    return 0;


// 计算最少需要多少枚导弹
//int minMissiles(const vector<int>& planes) {
//    vector<int> missiles; // 每个导弹当前能打的最大高度（不升序）
//
//    for (int height : planes) {
//        // 手动查找：找第一个大于等于当前高度的导弹
//        int index = -1;
//        for (int i = 0; i < missiles.size(); ++i) {
//            if (missiles[i] >= height) {
//                if (index == -1 || missiles[i] > missiles[index]) {
//                    index = i; // 找到最优导弹（高度尽量大）
//                }
//            }
//        }
//
//        if (index == -1) {
//            // 没有可用导弹，发射新导弹
//            missiles.push_back(height);
//        }
//        else {
//            // 更新导弹高度为当前飞机高度
//            missiles[index] = height;
//        }
//    }
//
//    return missiles.size();
//}
//
//// 主函数，测试用例
//int main() {
//    vector<int> planes = { 5, 3, 4, 4, 2 };
//
//    cout << "最少需要导弹数: " << minMissiles(planes) << endl;
//
//    // 更多测试
//    vector<int> test1 = { 9, 8, 7, 6 };
//    vector<int> test2 = { 1, 2, 3, 4 };
//    vector<int> test3 = { 3, 3, 3, 3 };
//
//    cout << "测试用例1（全降）结果: " << minMissiles(test1) << endl;
//    cout << "测试用例2（全升）结果: " << minMissiles(test2) << endl;
//    cout << "测试用例3（全等）结果: " << minMissiles(test3) << endl;
//
//    return 0;
//}
//


//using namespace std;
//
//struct Point {
//    double x, y;
//};
//
//double distance(const Point& a, const Point& b) {
//    return hypot(a.x - b.x, a.y - b.y);
//}
//
//// 总距离
//double totalCost(const vector<Point>& people, const vector<Point>& facilities) {
//    double total = 0;
//    for (const auto& person : people) {
//        double minDist = numeric_limits<double>::max();
//        for (const auto& fac : facilities) {
//            minDist = min(minDist, distance(person, fac));
//        }
//        total += minDist;
//    }
//    return total;
//}
//
//// 贪心选址 + 本地搜索优化
//vector<Point> greedyPmedian(const vector<Point>& people, int p, int maxIterations = 1000) {
//    int n = people.size();
//    vector<Point> bestFacilities;
//
//    // 初始随机选择 p 个点作为邮局
//    vector<int> indices(n);
//    for (int i = 0; i < n; ++i) indices[i] = i;
//    random_shuffle(indices.begin(), indices.end());
//
//    for (int i = 0; i < p; ++i)
//        bestFacilities.push_back(people[indices[i]]);
//
//    double bestCost = totalCost(people, bestFacilities);
//
//    // 局部搜索优化
//    for (int iter = 0; iter < maxIterations; ++iter) {
//        vector<Point> newFacilities = bestFacilities;
//        // 尝试用某个居民点替换现有邮局
//        int replaceIdx = rand() % p;
//        int newIdx = rand() % n;
//        newFacilities[replaceIdx] = people[newIdx];
//
//        double newCost = totalCost(people, newFacilities);
//
//        if (newCost < bestCost) {
//            bestCost = newCost;
//            bestFacilities = newFacilities;
//        }
//    }
//
//    return bestFacilities;
//}
//
//int main() {
//    srand(time(0));
//
//    int n, p;
//    cout << "输入居民数量: ";
//    cin >> n;
//    cout << "输入要建的邮局数量 p: ";
//    cin >> p;
//
//    vector<Point> people(n);
//    cout << "输入每个居民的二维坐标（x y）:\n";
//    for (int i = 0; i < n; ++i) {
//        cin >> people[i].x >> people[i].y;
//    }
//
//    vector<Point> result = greedyPmedian(people, p);
//
//    cout << "\n建议建邮局的位置为:\n";
//    for (int i = 0; i < result.size(); ++i) {
//        cout << "邮局 " << i + 1 << ": (" << result[i].x << ", " << result[i].y << ")\n";
//    }
//
//    cout << "\n总距离开销为: " << totalCost(people, result) << endl;
//
//    return 0;
//}

//int main()
//{
//	cout << __FILE__ << endl;
//	cout << __TIME__ << endl;
//
//	return 0;
//}

//int main()
//{
//	int a1 = 1;
//	int* a = &a1;
//	//*(int*)a = nullptr;
//	return 0;
//}

//template <class T>
//void Delete(T* obj)
//{
//	*(int*)obj = nullptr;
//}
//
//int main()
//{
//	cout << char('a' + 1) << endl;
//	int a = 1;
//	int* p = &a;
//
//	//*(long long*)p = nullptr
//	return 0;
//}


//class A
//{
//public:
//	void test()
//	{
//		cout << "Hello C++" << endl;
//	}
//
//private:
//	int _a;
//};
//
//class B
//{
//public:
//
//};
//
//int main()
//{
//	printf("%p\n", &A::test);
//	cout << &A::test << endl;
//	cout << sizeof(B) << endl;
//	return 0;
//}
//
//class Test 
//{
//public:
//	void Func()
//	{
//		cout << "Hello C++" << endl;
//		//cout << _a << endl;
//	}
//private:
//	int _a;
//};
//
//int main()
//{
//	Test* a = nullptr;
//	a->Func();
//	(*a).Func();
//
//	return 0;
//}


//class MyClass
//{
//public:
//	static void memberFunction()
//	{
//		std::cout << "void memberFunction()" << std::endl;
//	}
//	void func()
//	{
//		cout << "Hello linux " << endl;
//	}
//};
//
//int main()
//{
//	//MyClass obj;
//
//	//// 方法 1: 获取并打印成员函数的地址
//	//void (MyClass:: * funcPtr)() = &MyClass::memberFunction;
//
//	//// 打印成员函数的地址
//	//std::cout << "成员函数地址: " << reinterpret_cast<uintptr_t>(funcPtr) << std::endl;
//
//	//// 调用成员函数
//	//(obj.*funcPtr)();
//
//	//MyClass a;
//	//void (MyClass:: * funcPtr)() = &MyClass::memberFunction;
//	//cout << a.memberFunction() << endl;
//
//	cout << MyClass::memberFunction << endl;
//	//cout << MyClass::func << endl;
//
//	return 0;
//}

//class MyClass {
//public:
//    void memberFunction() {
//        std::cout << "This is a member function!" << std::endl;
//    }
//};
//
//int main() {
//    // 定义成员函数指针
//    void (MyClass:: * funcPtr)() = &MyClass::memberFunction;
//
//    // 打印成员函数指针
//    std::cout << "Address of member function pointer: " << funcPtr << std::endl;
//
//    // 使用成员函数指针调用函数
//    MyClass obj;
//    (obj.*funcPtr)(); // 通过对象调用成员函数    
//    auto funcAddr = reinterpret_cast<void*>(&MyClass::memberFunction);
//    cout << "Address of member function: " << funcAddr << endl;
//
//
//    return 0;
//}


//class A
//{
//public:
//	void Print()
//	{
//		cout << "Hello linux " << endl;
//	}
////private:
//	int _a;
//};
//int main()
//{
//	A a1, a2;
//	//cout << a1._a << " " << a2._a << endl;
//	//cout << &a1.Print() << " " << a2.Print() << endl; 
//	/*void (A:: * funcPtr)() = &A::Print;
//	cout << funcPtr << endl;*/
//
//	//cout << static_cast<a1.Print()> << endl;
//
//	void (A::*funcPtr)() = &A::Print;
//	
//	a1.Print();
//
//	return 0;
//}


//int main()
//{
//	cout << "I don't know" << endl;
//	return 0;
//}


//#define ADD(a,b) ((a) + (b))
//
//int Add(int a, int b)
//{
//	return a + b;
//}
//
//inline int Sub(int a, int b)
//{
//	return a - b;
//}
//
//int main()
//{
//	int a = 1;
//	int& b = a;
//	//cout << Add(1, Add(1,2)) << endl;
//	int c = Add(1, 2);
//	int d = Sub(1, 2);
//
//	cout << Sub(1, 2) << endl;
//	cout << Sub(1, 2) << endl;
//	cout << Sub(1, 2) << endl;
//
//	return 0;
//}